import axios from 'axios'     //引入
import qs from 'qs'     //引入
import { Notification, Loading, Message } from 'element-ui';

import Rsa from './rsa'
import Aes from './aes'
import utils from './utils'
import authKey from './authKey'

let flag = true; // 是否正式环境
let loadingInstance = "";
let baseURL = flag ? 'https://api.emo.yingling88.cn' : "https://im.smallyang.cn"

let config = {
    baseURL: baseURL,
    timeout: 30000,   //设置最大请求时间
    headers: {
        'os': 'h5',
    },
}
const _axios = axios.create(config)

let errorCode = {
    500: "服务器意外错误",
    400: "参数校验失败",
    404: "方法不存在",
    406: "请求方法不允许",
    401: "请重新登录",
    425: "当前网络拥堵",
    1000: "校验码不正确",
    1001: "未实名",
    1002: "房间密码错误",
    1003: "账户金币不足",
}

/* 请求拦截器（请求之前的操作） */
_axios.interceptors.request.use(
    config => {
        //   //如果有需要在这里开启请求时的loading动画效果
        loadingInstance = Loading.service()
        let message = {};

        // 是否开启加密
        if (flag) {
            if (config.url == '/api/file/upload_guild') {

            } else {
                if (config.method == 'post') {
                    message = Aes.encrypt({
                        ...config.data,
                        request_timestamp: Math.round(new Date().getTime() / 1000) + 3,
                        request_nocestr: utils.randomNumber(),
                    })
                    config.data = {
                        EncryData: message.appKey,
                    }
                } else {
                    message = Aes.encrypt({
                        ...config.params,
                        request_timestamp: Math.round(new Date().getTime() / 1000) + 3,
                        request_nocestr: utils.randomNumber(),
                    })

                    config.params = {
                        EncryData: message.appKey
                    }
                }

                console.log(message, "============加密的消息");
                config.headers['Encoded-Aes-Key'] = encodeURIComponent(Rsa.encrypt(message.keyStr));
            }
        }

        //添加token,需要结合自己的实际情况添加，
        if (config.url.indexOf("/api/auth/guild_login") == -1) {
            if (config.url.indexOf('/api/system/send_code') !== -1) {
                if (flag) {
                    config.url = authKey(config.url)
                }
                return config;
            }
            if (sessionStorage.getItem("user") && sessionStorage.getItem("user") !== "undefined") {
                let token = JSON.parse(sessionStorage.getItem("user")).token;
                console.log(config.url, "====请求路径");
                config.headers.Authorization = token;

            } else {
                Message.error('请重新登录')
                return false
            }
        }
        if (flag) {
            config.url = authKey(config.url)
        }
        return config;
    },
    err => Promise.reject(err)
);

/* 响应拦截器 (请求之后的操作) */
_axios.interceptors.response.use(
    res => {
        //在这里关闭请求时的loading动画效果   
        loadingInstance.close();

        console.log(res, "===============httpindex", res.data.code);
        if (res.data.code !== 200) {
            if (errorCode[res.data.code]) {
                Notification({
                    title: '请求失败',
                    message: errorCode[res.data.code],
                    type: 'error'
                })
            } else {
                Notification({
                    title: '请求失败',
                    message: res.data.msg,
                    type: 'error'
                })
            }
        }

        let httpData;
        if (flag) {
            let rsaVal = res.headers['encoded-aes-key'];
            //这里用于处理返回的结果，比如如果是返回401无权限，可能会是跳回到登录页的操作，结合自己的业务逻辑写
            // 解密
            let rsaVal1 = Rsa.decrypt(rsaVal);
            httpData = Aes.decrypt(res.data.data, rsaVal1);
            console.log(rsaVal1, "----返回值", res.data.data);
        } else {
            httpData = res.data;
        }
        if (typeof (httpData) == "string") {
            httpData = JSON.parse(httpData);
        }
        console.log(httpData, "---正确返回")
        if (httpData.code == 200) {
            // 返回正确的结果(then接受数据)
            if (httpData.data == null) {
                httpData.data = {};
            }
            if (httpData.data.list !== undefined) {
                if (httpData.data.list == null) {
                    httpData.data.list = []
                }
            }
            return Promise.resolve(httpData);
        }
    },
    err => {
        loadingInstance.close();
        if (err) {
            //在这里关闭请求时的loading动画效果
            // console.log(err.message.split('code')[1], "---------错误");
            // if (errorCode[err.message.split('code')[1].trim()]) {
            //     Notification({
            //         title: '请求失败',
            //         message: errorCode[err.message.split('code')[1].trim()],
            //         type: 'error'
            //     })
            // } else {
            console.log(err, "==========网络异常信息");
            Notification({
                title: '网络异常',
                message: err,
                type: 'error'
            })
            // }
        }
        return Promise.reject(err);
    }
);

//封装post,get方法
const http = {
    get(url = '', params = {}) {
        return new Promise((resolve, reject) => {
            _axios({
                url,
                params,
                method: 'GET'
            }).then(res => {
                resolve(res)
                return res
            }).catch(error => {
                reject(error)
            })
        })
    },
    post(url = '', params = {}) {
        return new Promise((resolve, reject) => {
            _axios({
                url,
                data: params,
                method: 'POST'
            }).then(res => {
                resolve(res)
                return res
            }).catch(error => {
                reject(error)
            })
        })
    }
}


export default http
